package com.blueocean_health.care.management.service;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.blueocean_health.care.management.common.LocalManager;
import com.blueocean_health.care.management.common.base.math.MathUtils;
import com.blueocean_health.care.management.common.base.string.StringUtils;
import com.blueocean_health.care.management.domain.base.Role;
import com.blueocean_health.care.management.domain.base.Team;
import com.blueocean_health.care.management.domain.base.UserTeam;
import com.blueocean_health.care.management.domain.vo.LoginDataVo;
import com.blueocean_health.care.management.em.LocalManagerType;
import com.blueocean_health.care.management.exception.OrganizationException;
import com.blueocean_health.care.management.mapper.TeamMapper;
import com.blueocean_health.care.management.mapper.UserTeamMapper;

/**
* 组织项目共用方法
* @author huyanqiu
* @date 2018年3月20日 下午6:51:06
* @version 版本号：1.0
*/
@Service
public class OrgAndProjectService {
	
	@Autowired
	private TeamMapper teamMapper;
	@Autowired
	private UserTeamMapper userTeamMapper;
	
	// 组织层级
	private static final int ORGANIZATIONLEVEL = 6;
	private static final int DIGIT = 3;
	
	public static void main(String[] args) {
	}

	/**
	 * 获得当前登录人所在组织对应的负责人/项目经理通用角色
	 * @param category 1：负责人  2：项目经理
	 * @return
	 */
	public Role getManagerPublicRole(String category) {
		// 当前登录人信息
		LoginDataVo courrentUser = LocalManager.getVal(LocalManagerType.LOGIN_DATA);
		Map<String, String> paramsMap = new HashMap<>();
		paramsMap.put("firstOrg", courrentUser.getUser().getFirstOrg()+"");
		paramsMap.put("category", category);
		// 当前登录人所在组织关联负责人通用角色
		// 查询相关联的负责人角色
		Role role = teamMapper.findManageRole(paramsMap);
		if (StringUtils.isEmpty(role)) {
			throw new OrganizationException("没有为该机构配置负责人/项目经理通用角色");
		}
		return role;
	}
	
	
	/**
	 * 获得code对应的所有下级
	 * @param code 001012000000000000 返回 001012 本级和下级可以用like匹配   '001012%'
	 * @return   
	 */
	public String getSubLikeCode(String code) {
		int level = getOrgLevel(code);
		List<String> codeList = codeStr2List(code);
		StringBuffer sb = new StringBuffer();
		for (int i=0; i<level; i++) {
			sb.append(codeList.get(i));
		}
		return sb.toString();
	}
	
	/**
	 * 获得当前及下级的组织/项目
	 * @param parentTeamId 父组织ID
	 * @param isSub 是否直接下级   true: 父组织ID的直接下级   false：父组织ID对应的所有下级
	 * @param isActive 是否可用  true: 启用状态组织   false：启用/禁用状态组织
	 * @return 所有下级组织的teamId集合
	 */
	public List<String> getAllSubTeamId(String parentTeamId, boolean isSub, boolean isActive) {
		if (StringUtils.isEmpty(parentTeamId, isSub, isActive)) {
			throw new RuntimeException("参数异常");
		}
		Team parentTeam = teamMapper.findOrgById(Integer.parseInt(parentTeamId));
		if (StringUtils.isEmpty(parentTeam)) {
			throw new RuntimeException("找不到指定的组织");
		}
		Map<String, String> paramsMap = new HashMap<>();
		if (isSub) {
			paramsMap.put("parentTeamId", parentTeamId);
		} else {
			String subLikeCode = getSubLikeCode(parentTeam.getCode());
			paramsMap.put("subLikeCode", subLikeCode);
		}
		if (isActive) {
			paramsMap.put("isActive", "1");
		} else {
			paramsMap.put("isActive", "3");
		}
		return teamMapper.selectSubTeam(paramsMap);
	}
	
	/**
	 * 获得当前及下级的组织/项目(启用/禁用)
	 * @param parentTeamId 父组织ID
	 * @return
	 */
	public List<String> getAllSubTeamId(String parentTeamId) {
		return getAllSubTeamId(parentTeamId, false, false);
	}
	
	/**
	 * 获取下一个组织code值
	 * @param code
	 * @param size
	 * @return
	 */
	public String getNextCode(String code, int size) {
		StringBuffer sb = new StringBuffer();
		sb.append(getSubLikeCode(code));
		sb.append(MathUtils.makeUpZeroData(size+1+"", DIGIT));
		int length = sb.length();
		for (int i=0; i<(18-length); i++) {
			sb.append("0");
		}
		return sb.toString();
	}
	
	/**
	 * 获取下一个项目code值
	 * @param code
	 * @param size
	 * @return
	 */
	public String getNextProjectCode(String code, int size) {
		StringBuffer sb = new StringBuffer();
		sb.append(code.substring(0, 15));
		sb.append(MathUtils.makeUpZeroData(size+1+"", DIGIT));
		return sb.toString();
	}
	
	/**
	 * 获得code对应的所有上级
	 * @param code 100200300400500600    上级：[100200300400500000, 100200300400000000, 100200300000000000, 100200000000000000, 100000000000000000]
	 * @return   
	 */
	public List<String> getUpLikeCode(String code) {
		List<String> upCodeList = new ArrayList<>();
		int level = getOrgLevel(code);
		List<String> codeList = codeStr2List(code);
		for (int i=0; i<level-1; i++) {
			StringBuffer sb = new StringBuffer();
			for (int j=0; j<=i; j++) {
				sb.append(codeList.get(j));
			}
			for (int k=1; k<ORGANIZATIONLEVEL-i; k++) {
				sb.append("000");
			}
			upCodeList.add(sb.toString());
		}
		return upCodeList;
	}
	
	/**
	 * 根据code返回当前层级
	 * @param code
	 * @return
	 */
	public int getOrgLevel(String code) {
		List<String> matchList = new ArrayList<>();
		matchList.add("\\d{3}0{15}"); // 第一层级
		matchList.add("\\d{6}0{12}"); // 第二层级
		matchList.add("\\d{9}0{9}");  // 第三层级
		matchList.add("\\d{12}0{6}"); // 第四层级 
		matchList.add("\\d{15}0{3}"); // 第五层级 
		matchList.add("\\d{18}"); // 第五层级 
		int level = -1;
		for (int i=0; i<matchList.size(); i++) {
			if (code.matches(matchList.get(i))) {
				level = (i+1);
				break;
			}
		}
		return level;
	}
	
	/**
	 * 根据code转化成List
	 * @param code
	 * @return
	 */
	private List<String> codeStr2List(String code) {
		List<String> codeList = new ArrayList<String>();
		for (;code.length()>DIGIT;) {
			codeList.add(code.substring(code.length()-DIGIT));
			code = code.substring(0, code.length()-DIGIT);
		}
		codeList.add(code);
		Collections.reverse(codeList);
		return codeList;
	}
	
	/**
	 * 指定组织是当前登录人组织的上下级、平级关系
	 * @return 上级：1   平级：0   下级 ：-1
	 */
	public int orgRelationship (int orgId) {
		// 指定组织信息
		Team organ = teamMapper.selectByPrimaryKey(orgId);
		if (StringUtils.isEmpty(organ)) {
			throw new OrganizationException("上级组织不存在");
		}
		return orgRelationship(organ.getCode());
	} 
	
	/**
	 * 指定组织code是当前登录人组织的上下级、平级关系
	 * @return (指定组织是当前登录人的) 上级：1   平级：0   下级 ：-1
	 */
	public int orgRelationship (String code) {
		// 使用方式用于登录人为三级组织不能编辑平级和上级组织下的项目
		// 获得登录人信息
		LoginDataVo loginDataVo = LocalManager.getVal(LocalManagerType.LOGIN_DATA);
		// 登录人所在组织信息
		Team courrentOrgan = teamMapper.selectByPrimaryKey(loginDataVo.getCurrentTeam().getTeamId());
		String prefix = getSubLikeCode(courrentOrgan.getCode());
		// 下级
		boolean isLowerLevel = code.startsWith(prefix);
		if (isLowerLevel) {
			return -1;
		}
		// 平级
		if (getOrgLevel(code)==getOrgLevel(courrentOrgan.getCode())) {
			return 0;
		}
		return 1;
	} 
	/**
	 * 更新负责人/项目经理==场景编辑组织/项目时调用该方法
	 * @param paramsMap<teamId：项目/组织ID  manager： 项目经理/组织负责人 ID category:1负责人 2项目经理>
	 * @param team
	 */
	public void updateManager(Map<String, String> paramsMap) {
		String teamId = paramsMap.get("teamId");
		String category = paramsMap.get("category");
		// 1、查询关联的项目经理角色信息
		Role managerRole = getManagerPublicRole(category);
		// 2、查询本组织/项目关联的负责人/项目经理
		Map<String, String> managerMap = new HashMap<>();
		managerMap.put("roleId", managerRole.getRoleId()+"");
		managerMap.put("teamId", teamId);
		managerMap.put("status", managerRole.getIsActive()+"");
		managerMap.put("category", category);
		UserTeam oldManager = teamMapper.findManagerByRoleIdAndTeamId(managerMap);
		// 3、对比更新前后的项目经理关系<更新>
		String newManager = paramsMap.get("manager");
		
		// 3.1、查询编辑新入的负责人/项目经理，是否在角色授权，用户模块授权已经授权，如果已经授权则覆盖(具体操作：删除、新建)
		UserTeam isUniqueManage = new UserTeam();
		if (!StringUtils.isEmpty(newManager)) {
			Map<String, String> isUniqueManageMap = new HashMap<>();
			isUniqueManageMap.put("roleId", managerRole.getRoleId()+"");
			isUniqueManageMap.put("teamId", teamId);
			isUniqueManageMap.put("status", managerRole.getIsActive()+"");
			isUniqueManageMap.put("userId", newManager);
			isUniqueManage = teamMapper.findNotManagerByRoleIdAndTeamId(isUniqueManageMap);
			// 删除角色模块、用户模块的授权
			if (!StringUtils.isEmpty(isUniqueManage)) {
				userTeamMapper.deleteByPrimaryKey(isUniqueManage.getId());
			}
		}
		
		if (StringUtils.isEmpty(oldManager)) {
			if (!StringUtils.isEmpty(newManager)) {
				// 新增项目经理 save newManager
				UserTeam bean = new UserTeam();
				bean.setUserId(Integer.parseInt(newManager));
				bean.setRoleId(managerRole.getRoleId()); // 角色id
				bean.setTeamId(Integer.parseInt(teamId)); // 项目id
				bean.setCategory(category); // 标识组织/项目模块获得负责人，项目经理角色：1:负责人 2:项目经理  null：其他
				bean.setIsActive(managerRole.getIsActive()); // 逻辑状态 1正常，2禁用，3 删除
				bean.setCreateTime(new Date()); // 创建时间
				userTeamMapper.insert(bean);
			}
		} else {
			if (StringUtils.isEmpty(newManager)) {
				// 删除原来项目经理  delete oldManager
				userTeamMapper.deleteByPrimaryKey(oldManager.getId());
			} else {
				if (!newManager.equals(oldManager.getUserId()+"")) {
					// 删除原来项目经理
					userTeamMapper.deleteByPrimaryKey(oldManager.getId());
					// 新增项目经理
					UserTeam bean = new UserTeam();
					bean.setUserId(Integer.parseInt(newManager));
					bean.setRoleId(managerRole.getRoleId()); // 角色id
					bean.setTeamId(Integer.parseInt(teamId)); // 项目id
					bean.setCategory(category); // 标识组织/项目模块获得负责人，项目经理角色：1:负责人 2:项目经理  null：其他
					bean.setIsActive(managerRole.getIsActive()); // 逻辑状态 1正常，2禁用，3 删除
					bean.setCreateTime(new Date()); // 创建时间
					userTeamMapper.insert(bean);
				}
			}
		}
	}
	
}
